import { http } from "@/utils/http";

/** 统一响应格式 */
export interface ApiResponse<T = any> {
  /** 状态码 */
  code: number;
  /** 响应消息 */
  message: string;
  /** 响应数据 */
  data?: T;
  /** 时间戳 */
  timestamp?: number;
}

// ==================== 榜单类型和维度枚举 ====================

/** 榜单类型 */
export enum RankingType {
  /** 文章榜 */
  ARTICLE = "ARTICLE",
  /** 作者榜 */
  AUTHOR = "AUTHOR",
  /** 收藏榜 */
  COLLECTION = "COLLECTION"
}

/** 榜单维度 */
export enum RankingDimension {
  /** 综合榜（全站） */
  OVERALL = "OVERALL",
  /** 分类榜（按分类） */
  CATEGORY = "CATEGORY"
}

// ==================== 请求参数类型 ====================

/** 榜单查询请求参数 */
export interface RankingRequest {
  /** 榜单类型 */
  rankingType: RankingType;
  /** 榜单维度 */
  dimension: RankingDimension;
  /** 分类ID（维度为CATEGORY时必填） */
  categoryId?: number;
  /** 当前页码（默认1） */
  current?: number;
  /** 每页大小（默认10，最大50） */
  size?: number;
  /** 是否只获取TOP N（不分页） */
  topOnly?: boolean;
  /** TOP N的数量（topOnly为true时有效，默认10，最大50） */
  topN?: number;
}

/** 查询排名请求参数 */
export interface RankingQueryRequest {
  /** 榜单类型 */
  rankingType: RankingType;
  /** 榜单维度 */
  dimension: RankingDimension;
  /** 目标ID（文章ID或作者ID） */
  targetId: number;
  /** 分类ID（维度为CATEGORY时必填） */
  categoryId?: number;
}

// ==================== 响应数据类型 ====================

/** 榜单项 */
export interface RankingItem {
  /** 排名 */
  rank: number;
  /** 目标ID（文章ID或作者ID） */
  targetId: number;
  /** 热度分数 */
  heatScore: number;
  /** 标题（文章标题或作者昵称） */
  title: string;
  /** 副标题（作者昵称或作者签名） */
  subtitle?: string;
  /** 封面图片URL（文章榜、收藏榜） */
  coverImage?: string;
  /** 头像URL（作者榜） */
  avatar?: string;
  /** 浏览量 */
  viewCount?: number;
  /** 点赞数 */
  likeCount?: number;
  /** 收藏数 */
  collectCount?: number;
  /** 评论数 */
  commentCount?: number;
  /** 分享数 */
  shareCount?: number;
  /** 粉丝数（作者榜） */
  fansCount?: number;
  /** 文章数（作者榜） */
  articleCount?: number;
  /** 发布时间 */
  publishTime?: string;
  /** 分类ID */
  categoryId?: number;
  /** 分类名称 */
  categoryName?: string;
  /** 作者ID */
  authorId?: number;
  /** 作者昵称 */
  authorNickName?: string;
  /** 作者头像 */
  authorAvatar?: string;
  /** 排名变化（正数=上升，负数=下降，0=不变，null=新上榜） */
  rankChange?: number;
  /** 是否新上榜 */
  isNew?: boolean;
  /** 是否已关注（作者榜，未登录时为null） */
  isFollowed?: boolean | null;
  /** 是否已收藏（文章榜/收藏榜，未登录时为null） */
  isCollected?: boolean | null;
}

/** 榜单响应 */
export interface RankingResponse {
  /** 榜单类型代码 */
  rankingType: string;
  /** 榜单类型名称 */
  rankingTypeName: string;
  /** 榜单维度代码 */
  dimension: string;
  /** 榜单维度名称 */
  dimensionName: string;
  /** 分类ID */
  categoryId?: number;
  /** 分类名称 */
  categoryName?: string;
  /** 榜单项列表 */
  items: RankingItem[];
  /** 总记录数 */
  total: number;
  /** 当前页码 */
  current: number;
  /** 每页大小 */
  size: number;
  /** 总页数 */
  pages: number;
  /** 是否有下一页 */
  hasNext: boolean;
  /** 是否有上一页 */
  hasPrevious: boolean;
  /** 榜单更新时间 */
  updateTime?: string;
  /** 下次更新时间 */
  nextUpdateTime?: string;
}

/** 排名查询响应 */
export interface RankingQueryResponse {
  /** 榜单类型 */
  rankingType: string;
  /** 榜单维度 */
  dimension: string;
  /** 目标ID */
  targetId: number;
  /** 分类ID */
  categoryId?: number;
  /** 排名 */
  rank?: number;
  /** 是否在榜单中 */
  inRanking: boolean;
}

/** 榜单统计信息 */
export interface RankingStatistics {
  /** 文章榜数量 */
  articleRankingCount: number;
  /** 作者榜数量 */
  authorRankingCount: number;
  /** 收藏榜数量 */
  collectionRankingCount: number;
  /** 总榜单数量 */
  totalRankingCount: number;
  /** 最后更新时间 */
  lastUpdateTime: string;
  /** 下次更新时间 */
  nextUpdateTime: string;
}

// ==================== API 接口函数 ====================

/**
 * 查询榜单（通用接口）
 * @param params 查询参数
 */
export const getRankingList = (params: RankingRequest) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    "/api/ranking/list",
    {
      params
    }
  );
};

/**
 * 获取文章榜（综合）
 * @param current 当前页码
 * @param size 每页大小
 */
export const getArticleOverallRanking = (current = 1, size = 50) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    "/api/ranking/article/overall",
    {
      params: { current, size }
    }
  );
};

/**
 * 获取文章榜（分类）
 * @param categoryId 分类ID
 * @param current 当前页码
 * @param size 每页大小
 */
export const getArticleCategoryRanking = (
  categoryId: number,
  current = 1,
  size = 50
) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    `/api/ranking/article/category/${categoryId}`,
    {
      params: { current, size }
    }
  );
};

/**
 * 获取作者榜（综合）
 * @param current 当前页码
 * @param size 每页大小
 */
export const getAuthorOverallRanking = (current = 1, size = 50) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    "/api/ranking/author/overall",
    {
      params: { current, size }
    }
  );
};

/**
 * 获取作者榜（分类）
 * @param categoryId 分类ID
 * @param current 当前页码
 * @param size 每页大小
 */
export const getAuthorCategoryRanking = (
  categoryId: number,
  current = 1,
  size = 50
) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    `/api/ranking/author/category/${categoryId}`,
    {
      params: { current, size }
    }
  );
};

/**
 * 获取收藏榜（综合）
 * @param current 当前页码
 * @param size 每页大小
 */
export const getCollectionOverallRanking = (current = 1, size = 50) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    "/api/ranking/collection/overall",
    {
      params: { current, size }
    }
  );
};

/**
 * 获取收藏榜（分类）
 * @param categoryId 分类ID
 * @param current 当前页码
 * @param size 每页大小
 */
export const getCollectionCategoryRanking = (
  categoryId: number,
  current = 1,
  size = 50
) => {
  return http.request<ApiResponse<RankingResponse>>(
    "get",
    `/api/ranking/collection/category/${categoryId}`,
    {
      params: { current, size }
    }
  );
};

/**
 * 查询指定目标的排名
 * @param rankingType 榜单类型
 * @param dimension 榜单维度
 * @param targetId 目标ID
 * @param categoryId 分类ID（可选）
 */
export const getRankingPosition = (
  rankingType: RankingType,
  dimension: RankingDimension,
  targetId: number,
  categoryId?: number
) => {
  return http.request<ApiResponse<RankingQueryResponse>>(
    "get",
    "/api/ranking/rank",
    {
      params: { rankingType, dimension, targetId, categoryId }
    }
  );
};

// ==================== 管理接口（需要 admin 权限）====================

/**
 * 刷新所有榜单
 */
export const refreshAllRankings = () => {
  return http.request<ApiResponse<null>>(
    "post",
    "/api/ranking/admin/refresh/all"
  );
};

/**
 * 刷新指定榜单
 * @param rankingType 榜单类型
 * @param dimension 榜单维度
 * @param categoryId 分类ID（可选）
 */
export const refreshRanking = (
  rankingType: RankingType,
  dimension: RankingDimension,
  categoryId?: number
) => {
  return http.request<ApiResponse<null>>("post", "/api/ranking/admin/refresh", {
    params: { rankingType, dimension, categoryId }
  });
};

/**
 * 更新榜单项
 * @param rankingType 榜单类型
 * @param targetId 目标ID
 */
export const updateRankingItem = (
  rankingType: RankingType,
  targetId: number
) => {
  return http.request<ApiResponse<null>>("post", "/api/ranking/admin/update", {
    params: { rankingType, targetId }
  });
};

/**
 * 从榜单中移除项
 * @param rankingType 榜单类型
 * @param targetId 目标ID
 */
export const removeRankingItem = (
  rankingType: RankingType,
  targetId: number
) => {
  return http.request<ApiResponse<null>>(
    "delete",
    "/api/ranking/admin/remove",
    {
      params: { rankingType, targetId }
    }
  );
};

/**
 * 清空所有榜单
 */
export const clearAllRankings = () => {
  return http.request<ApiResponse<null>>("post", "/api/ranking/admin/clear");
};

/**
 * 获取榜单统计信息
 */
export const getAdminRankingStatistics = () => {
  return http.request<ApiResponse<RankingStatistics>>(
    "get",
    "/api/ranking/admin/statistics"
  );
};

/**
 * 获取榜单健康状态
 */
export const getRankingHealth = () => {
  return http.request<ApiResponse<any>>("get", "/api/ranking/admin/health");
};
